// Copyright 2015 the V8 project authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "src/interpreter/bytecode-array-accessor.h"

#include "src/feedback-vector.h"
#include "src/interpreter/bytecode-decoder.h"
#include "src/interpreter/interpreter-intrinsics.h"
#include "src/objects-inl.h"
#include "src/objects/code-inl.h"

namespace v8 {
namespace internal {
    namespace interpreter {

        BytecodeArrayAccessor::BytecodeArrayAccessor(
            Handle<BytecodeArray> bytecode_array, int initial_offset)
            : bytecode_array_(bytecode_array)
            , bytecode_offset_(initial_offset)
            , operand_scale_(OperandScale::kSingle)
            , prefix_offset_(0)
        {
            UpdateOperandScale();
        }

        void BytecodeArrayAccessor::SetOffset(int offset)
        {
            bytecode_offset_ = offset;
            UpdateOperandScale();
        }

        void BytecodeArrayAccessor::ApplyDebugBreak()
        {
            // Get the raw bytecode from the bytecode array. This may give us a
            // scaling prefix, which we can patch with the matching debug-break
            // variant.
            interpreter::Bytecode bytecode = interpreter::Bytecodes::FromByte(bytecode_array_->get(bytecode_offset_));
            if (interpreter::Bytecodes::IsDebugBreak(bytecode))
                return;
            interpreter::Bytecode debugbreak = interpreter::Bytecodes::GetDebugBreak(bytecode);
            bytecode_array_->set(bytecode_offset_,
                interpreter::Bytecodes::ToByte(debugbreak));
        }

        void BytecodeArrayAccessor::UpdateOperandScale()
        {
            if (OffsetInBounds()) {
                uint8_t current_byte = bytecode_array()->get(bytecode_offset_);
                Bytecode current_bytecode = Bytecodes::FromByte(current_byte);
                if (Bytecodes::IsPrefixScalingBytecode(current_bytecode)) {
                    operand_scale_ = Bytecodes::PrefixBytecodeToOperandScale(current_bytecode);
                    prefix_offset_ = 1;
                } else {
                    operand_scale_ = OperandScale::kSingle;
                    prefix_offset_ = 0;
                }
            }
        }

        bool BytecodeArrayAccessor::OffsetInBounds() const
        {
            return bytecode_offset_ >= 0 && bytecode_offset_ < bytecode_array()->length();
        }

        Bytecode BytecodeArrayAccessor::current_bytecode() const
        {
            DCHECK(OffsetInBounds());
            uint8_t current_byte = bytecode_array()->get(bytecode_offset_ + current_prefix_offset());
            Bytecode current_bytecode = Bytecodes::FromByte(current_byte);
            DCHECK(!Bytecodes::IsPrefixScalingBytecode(current_bytecode));
            return current_bytecode;
        }

        int BytecodeArrayAccessor::current_bytecode_size() const
        {
            return current_prefix_offset() + Bytecodes::Size(current_bytecode(), current_operand_scale());
        }

        uint32_t BytecodeArrayAccessor::GetUnsignedOperand(
            int operand_index, OperandType operand_type) const
        {
            DCHECK_GE(operand_index, 0);
            DCHECK_LT(operand_index, Bytecodes::NumberOfOperands(current_bytecode()));
            DCHECK_EQ(operand_type,
                Bytecodes::GetOperandType(current_bytecode(), operand_index));
            DCHECK(Bytecodes::IsUnsignedOperandType(operand_type));
            Address operand_start = bytecode_array()->GetFirstBytecodeAddress() + bytecode_offset_ + current_prefix_offset() + Bytecodes::GetOperandOffset(current_bytecode(), operand_index, current_operand_scale());
            return BytecodeDecoder::DecodeUnsignedOperand(operand_start, operand_type,
                current_operand_scale());
        }

        int32_t BytecodeArrayAccessor::GetSignedOperand(
            int operand_index, OperandType operand_type) const
        {
            DCHECK_GE(operand_index, 0);
            DCHECK_LT(operand_index, Bytecodes::NumberOfOperands(current_bytecode()));
            DCHECK_EQ(operand_type,
                Bytecodes::GetOperandType(current_bytecode(), operand_index));
            DCHECK(!Bytecodes::IsUnsignedOperandType(operand_type));
            Address operand_start = bytecode_array()->GetFirstBytecodeAddress() + bytecode_offset_ + current_prefix_offset() + Bytecodes::GetOperandOffset(current_bytecode(), operand_index, current_operand_scale());
            return BytecodeDecoder::DecodeSignedOperand(operand_start, operand_type,
                current_operand_scale());
        }

        uint32_t BytecodeArrayAccessor::GetFlagOperand(int operand_index) const
        {
            DCHECK_EQ(Bytecodes::GetOperandType(current_bytecode(), operand_index),
                OperandType::kFlag8);
            return GetUnsignedOperand(operand_index, OperandType::kFlag8);
        }

        uint32_t BytecodeArrayAccessor::GetUnsignedImmediateOperand(
            int operand_index) const
        {
            DCHECK_EQ(Bytecodes::GetOperandType(current_bytecode(), operand_index),
                OperandType::kUImm);
            return GetUnsignedOperand(operand_index, OperandType::kUImm);
        }

        int32_t BytecodeArrayAccessor::GetImmediateOperand(int operand_index) const
        {
            DCHECK_EQ(Bytecodes::GetOperandType(current_bytecode(), operand_index),
                OperandType::kImm);
            return GetSignedOperand(operand_index, OperandType::kImm);
        }

        uint32_t BytecodeArrayAccessor::GetRegisterCountOperand(
            int operand_index) const
        {
            DCHECK_EQ(Bytecodes::GetOperandType(current_bytecode(), operand_index),
                OperandType::kRegCount);
            return GetUnsignedOperand(operand_index, OperandType::kRegCount);
        }

        uint32_t BytecodeArrayAccessor::GetIndexOperand(int operand_index) const
        {
            OperandType operand_type = Bytecodes::GetOperandType(current_bytecode(), operand_index);
            DCHECK_EQ(operand_type, OperandType::kIdx);
            return GetUnsignedOperand(operand_index, operand_type);
        }

        FeedbackSlot BytecodeArrayAccessor::GetSlotOperand(int operand_index) const
        {
            int index = GetIndexOperand(operand_index);
            return FeedbackVector::ToSlot(index);
        }

        Register BytecodeArrayAccessor::GetRegisterOperand(int operand_index) const
        {
            OperandType operand_type = Bytecodes::GetOperandType(current_bytecode(), operand_index);
            Address operand_start = bytecode_array()->GetFirstBytecodeAddress() + bytecode_offset_ + current_prefix_offset() + Bytecodes::GetOperandOffset(current_bytecode(), operand_index, current_operand_scale());
            return BytecodeDecoder::DecodeRegisterOperand(operand_start, operand_type,
                current_operand_scale());
        }

        int BytecodeArrayAccessor::GetRegisterOperandRange(int operand_index) const
        {
            DCHECK_LE(operand_index, Bytecodes::NumberOfOperands(current_bytecode()));
            const OperandType* operand_types = Bytecodes::GetOperandTypes(current_bytecode());
            OperandType operand_type = operand_types[operand_index];
            DCHECK(Bytecodes::IsRegisterOperandType(operand_type));
            if (operand_type == OperandType::kRegList || operand_type == OperandType::kRegOutList) {
                return GetRegisterCountOperand(operand_index + 1);
            } else {
                return Bytecodes::GetNumberOfRegistersRepresentedBy(operand_type);
            }
        }

        Runtime::FunctionId BytecodeArrayAccessor::GetRuntimeIdOperand(
            int operand_index) const
        {
            OperandType operand_type = Bytecodes::GetOperandType(current_bytecode(), operand_index);
            DCHECK_EQ(operand_type, OperandType::kRuntimeId);
            uint32_t raw_id = GetUnsignedOperand(operand_index, operand_type);
            return static_cast<Runtime::FunctionId>(raw_id);
        }

        uint32_t BytecodeArrayAccessor::GetNativeContextIndexOperand(
            int operand_index) const
        {
            OperandType operand_type = Bytecodes::GetOperandType(current_bytecode(), operand_index);
            DCHECK_EQ(operand_type, OperandType::kNativeContextIndex);
            return GetUnsignedOperand(operand_index, operand_type);
        }

        Runtime::FunctionId BytecodeArrayAccessor::GetIntrinsicIdOperand(
            int operand_index) const
        {
            OperandType operand_type = Bytecodes::GetOperandType(current_bytecode(), operand_index);
            DCHECK_EQ(operand_type, OperandType::kIntrinsicId);
            uint32_t raw_id = GetUnsignedOperand(operand_index, operand_type);
            return IntrinsicsHelper::ToRuntimeId(
                static_cast<IntrinsicsHelper::IntrinsicId>(raw_id));
        }

        Object BytecodeArrayAccessor::GetConstantAtIndex(int index) const
        {
            return bytecode_array()->constant_pool()->get(index);
        }

        Object BytecodeArrayAccessor::GetConstantForIndexOperand(
            int operand_index) const
        {
            return GetConstantAtIndex(GetIndexOperand(operand_index));
        }

        int BytecodeArrayAccessor::GetJumpTargetOffset() const
        {
            Bytecode bytecode = current_bytecode();
            if (interpreter::Bytecodes::IsJumpImmediate(bytecode)) {
                int relative_offset = GetUnsignedImmediateOperand(0);
                if (bytecode == Bytecode::kJumpLoop) {
                    relative_offset = -relative_offset;
                }
                return GetAbsoluteOffset(relative_offset);
            } else if (interpreter::Bytecodes::IsJumpConstant(bytecode)) {
                Smi smi = Smi::cast(GetConstantForIndexOperand(0));
                return GetAbsoluteOffset(smi->value());
            } else {
                UNREACHABLE();
            }
        }

        JumpTableTargetOffsets BytecodeArrayAccessor::GetJumpTableTargetOffsets()
            const
        {
            uint32_t table_start, table_size;
            int32_t case_value_base;
            if (current_bytecode() == Bytecode::kSwitchOnGeneratorState) {
                table_start = GetIndexOperand(1);
                table_size = GetUnsignedImmediateOperand(2);
                case_value_base = 0;
            } else {
                DCHECK_EQ(current_bytecode(), Bytecode::kSwitchOnSmiNoFeedback);
                table_start = GetIndexOperand(0);
                table_size = GetUnsignedImmediateOperand(1);
                case_value_base = GetImmediateOperand(2);
            }
            return JumpTableTargetOffsets(this, table_start, table_size, case_value_base);
        }

        int BytecodeArrayAccessor::GetAbsoluteOffset(int relative_offset) const
        {
            return current_offset() + relative_offset + current_prefix_offset();
        }

        bool BytecodeArrayAccessor::OffsetWithinBytecode(int offset) const
        {
            return current_offset() <= offset && offset < current_offset() + current_bytecode_size();
        }

        std::ostream& BytecodeArrayAccessor::PrintTo(std::ostream& os) const
        {
            const uint8_t* bytecode_addr = reinterpret_cast<const uint8_t*>(
                bytecode_array()->GetFirstBytecodeAddress() + bytecode_offset_);
            return BytecodeDecoder::Decode(os, bytecode_addr,
                bytecode_array()->parameter_count());
        }

        JumpTableTargetOffsets::JumpTableTargetOffsets(
            const BytecodeArrayAccessor* accessor, int table_start, int table_size,
            int case_value_base)
            : accessor_(accessor)
            , table_start_(table_start)
            , table_size_(table_size)
            , case_value_base_(case_value_base)
        {
        }

        JumpTableTargetOffsets::iterator JumpTableTargetOffsets::begin() const
        {
            return iterator(case_value_base_, table_start_, table_start_ + table_size_,
                accessor_);
        }
        JumpTableTargetOffsets::iterator JumpTableTargetOffsets::end() const
        {
            return iterator(case_value_base_ + table_size_, table_start_ + table_size_,
                table_start_ + table_size_, accessor_);
        }
        int JumpTableTargetOffsets::size() const
        {
            int ret = 0;
            // TODO(leszeks): Is there a more efficient way of doing this than iterating?
            for (const auto& entry : *this) {
                USE(entry);
                ret++;
            }
            return ret;
        }

        JumpTableTargetOffsets::iterator::iterator(
            int case_value, int table_offset, int table_end,
            const BytecodeArrayAccessor* accessor)
            : accessor_(accessor)
            , current_(Smi::zero())
            , index_(case_value)
            , table_offset_(table_offset)
            , table_end_(table_end)
        {
            UpdateAndAdvanceToValid();
        }

        JumpTableTargetOffset JumpTableTargetOffsets::iterator::operator*()
        {
            DCHECK_LT(table_offset_, table_end_);
            return { index_, accessor_->GetAbsoluteOffset(Smi::ToInt(current_)) };
        }

        JumpTableTargetOffsets::iterator& JumpTableTargetOffsets::iterator::
        operator++()
        {
            DCHECK_LT(table_offset_, table_end_);
            ++table_offset_;
            ++index_;
            UpdateAndAdvanceToValid();
            return *this;
        }

        bool JumpTableTargetOffsets::iterator::operator!=(
            const JumpTableTargetOffsets::iterator& other)
        {
            DCHECK_EQ(accessor_, other.accessor_);
            DCHECK_EQ(table_end_, other.table_end_);
            DCHECK_EQ(index_ - other.index_, table_offset_ - other.table_offset_);
            return index_ != other.index_;
        }

        void JumpTableTargetOffsets::iterator::UpdateAndAdvanceToValid()
        {
            if (table_offset_ >= table_end_)
                return;

            Object current = accessor_->GetConstantAtIndex(table_offset_);
            while (!current->IsSmi()) {
                DCHECK(current->IsTheHole());
                ++table_offset_;
                ++index_;
                if (table_offset_ >= table_end_)
                    break;
                current = accessor_->GetConstantAtIndex(table_offset_);
            }
            // Make sure we haven't reached the end of the table with a hole in current.
            if (current->IsSmi()) {
                current_ = Smi::cast(current);
            }
        }

    } // namespace interpreter
} // namespace internal
} // namespace v8
